package com.jasmine.core.util;

import java.lang.management.ManagementFactory;
import java.lang.management.RuntimeMXBean;
import java.net.NetworkInterface;
import java.net.SocketException;
import java.util.Enumeration;
import java.util.HashSet;
import java.util.Set;

/**
 * id自增器（雪花算法）
 *
 * @author renjie
 * @version 1.0.0
 */
@SuppressWarnings("ALL")
public class SnowFlake {
    private final static long TWEPOCH = 12888349746579L;

    private final static long WORKER_ID_BITS = 5L;                                                   // 机器标识位数
    private final static long DATA_CENTER_ID_BITS = 5L;                                               // 数据中心标识位数
    private final static long SEQUENCE_BITS = 12L;                                                  // 毫秒内自增位数
    private final static long WORKER_ID_SHIFT = SEQUENCE_BITS;                                        // 机器ID偏左移12位
    private final static long DATA_CENTER_ID_SHIFT = SEQUENCE_BITS + WORKER_ID_BITS;                     // 数据中心ID左移17位
    private final static long TIME_STAMP_LEFT_SHIFT = SEQUENCE_BITS + WORKER_ID_BITS + DATA_CENTER_ID_BITS; // 时间毫秒左移22位
    private final static long SEQUENCE_MASK = -1L ^ (-1L << SEQUENCE_BITS);       // sequence掩码,确保sequnce不会超出上限
    private static long LAST_TIMESTAMP = -1L;                                                       // 上次时间戳
    private long SEQUENCE = 0L;                                                                    // 序列
    private long WORKER_ID = 1L;                                                                    // 服务器ID
    private static long WORKER_MASK = -1L ^ (-1L << WORKER_ID_BITS);
    private long PROCESS_ID = 1L;                                                                   // 进程编码
    private static long PROCESS_MASK = -1L ^ (-1L << DATA_CENTER_ID_BITS);
    private static SnowFlake SnowFlake = null;

    static{
        SnowFlake = new SnowFlake();
    }

    private SnowFlake() {
        // 1. 获取机器编码
        this.WORKER_ID = this.getMachineNum();
        //获取进程编码
        RuntimeMXBean runtimeMXBean = ManagementFactory.getRuntimeMXBean();
        this.PROCESS_ID = Long.valueOf(runtimeMXBean.getName().split("@")[0]).longValue();

        //避免编码超出最大值
        this.WORKER_ID = WORKER_ID & WORKER_MASK;
        this.PROCESS_ID = PROCESS_ID & PROCESS_MASK;
    }

    /**
     * 获取机器编码
     * 计算机接口拼接而成的字符串的hashcode值
     */
    private long getMachineNum(){
        long machinePiece;
        StringBuilder sb = new StringBuilder();
        Enumeration<NetworkInterface> e = null;
        try {
            // 返回此计算机上的所有网络接口
            e = NetworkInterface.getNetworkInterfaces();
        } catch (SocketException e1) {
            e1.printStackTrace();
        }
        while (e.hasMoreElements()) {
            NetworkInterface ni = e.nextElement();
            sb.append(ni.toString());
        }
        machinePiece = sb.toString().hashCode();
        return machinePiece;
    }

    public static synchronized long nextId(){
        return SnowFlake.getNextId();
    }

    public synchronized long getNextId() {
        //获取时间戳
        long timestamp = timeGen();
        //如果时间戳小于上次时间戳则报错
        if (timestamp < LAST_TIMESTAMP) {
            try {
                throw new Exception("Clock moved backwards.  Refusing to generate id for " +
                        (LAST_TIMESTAMP - timestamp) +
                        " milliseconds");
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        //如果时间戳与上次时间戳相同
        if (LAST_TIMESTAMP == timestamp) {
            // 当前毫秒内，则+1，与sequenceMask确保sequence不会超出上限
            SEQUENCE = (SEQUENCE + 1) & SEQUENCE_MASK;
            if (SEQUENCE == 0) {
                // 当前毫秒内计数满了，则等待下一秒
                timestamp = tilNextMillis(LAST_TIMESTAMP);
            }
        } else {
            SEQUENCE = 0;
        }
        LAST_TIMESTAMP = timestamp;
        // ID偏移组合生成最终的ID，并返回ID
        long nextId =
            ((timestamp - TWEPOCH) << TIME_STAMP_LEFT_SHIFT) |
            (PROCESS_ID << DATA_CENTER_ID_SHIFT) |
            (WORKER_ID << WORKER_ID_SHIFT) |
            SEQUENCE;

        return nextId;
    }

    /**
     * 再次获取时间戳直到获取的时间戳与现有的不同
     * @param lastTimestamp
     * @return 下一个时间戳
     */
    private long tilNextMillis(final long lastTimestamp) {
        long timestamp = this.timeGen();
        while (timestamp <= lastTimestamp) {
            timestamp = this.timeGen();
        }
        return timestamp;
    }

    private long timeGen() {
        return System.currentTimeMillis();
    }




    private static Set<Long> keys = new HashSet<Long>();

//    public static void main(String[] args) {
//        long start = System.currentTimeMillis();
//        long key;
//        for (int i = 0; i < 1000000; i++) {
//            key = SnowFlake.nextId();
//            System.out.println(key);
//            if(keys.contains(key)){
//                System.out.println(key);
//            }else{
//                keys.add(key);
//            }
//        }
//        System.out.println("100 万ID耗时(毫秒) : " + (System.currentTimeMillis() - start));
//    }
}
